#include "stdbool.h"
#include "stdio.h"
#include "fsl_common.h"
#include "softspi.h"

#define USE_EXCEL 0
#define USE_DIFFERENCE 0
extern void SoftSpiGpioInit(void);
extern void SckSetValue(bool value);
extern void MosiSetValue(bool value);
extern bool MisoGetValue(void);
extern void NssSetValue(bool value);

void MySPI_W_SS(bool BitValue)
{
		NssSetValue(BitValue);
}

void MySPI_W_SCK(bool BitValue)
{
		SckSetValue(BitValue);
}

void MySPI_W_MOSI(bool BitValue)
{
		MosiSetValue(BitValue);
}

bool MySPI_R_MISO(void)
{
		return MisoGetValue();
}


void MySPI_Init(void)
{
		SoftSpiGpioInit();
		MySPI_W_SS(1);
		MySPI_W_SCK(0);
}

void MySPI_Start(void){
		MySPI_W_SS(0);
}

void MySPI_Stop(void)
{
		MySPI_W_SS(1);
}
#if 0
uint8_t MySPI_SwapByte(uint8_t ByteSend){
	uint8_t i,ByteReceive = 0;
	
	for(i=0;i<8;i++)
	{
		MySPI_W_MOSI(ByteSend & (0x80 >> i));
		MySPI_W_SCK(1);
		if(MySPI_R_MISO() == 1)
		{
			ByteReceive |= (0x80 >> i);
		}//
		MySPI_W_SCK(0);
	}
	return ByteReceive;
}

uint32_t SwapData(uint8_t* data,uint8_t sizeInByte,bool Cmd_selct)
{ 
	uint8_t temp[4] = {0};
	uint32_t ret = 0;
	MySPI_Start();
    if(Cmd_selct == false)
    {
        MySPI_W_MOSI(1);//data
    }else{
        MySPI_W_MOSI(0);
    }
    MySPI_W_SCK(1);
    MySPI_W_SCK(0);
	for(uint16_t i =0;i<sizeInByte;i++)
	{
		if(i == 0)
		{
			temp[i] = MySPI_SwapByte(data[i]);
		}else{
			temp[i] = MySPI_SwapByte(0);//dummytime
		}
			
	}
	for(uint8_t i = 0;i<sizeInByte;i++)
	{	
			ret = ret<<8;
			ret += temp[i];
	}
	MySPI_Stop();
	return ret;
}
#endif

void SPIWrite(uint32_t dat)
{
    MySPI_Start();//CS 0
    
    for(uint8_t i =9;i>0;i--)
    {
        MySPI_W_SCK(0);
        
        if(dat & 0x0100)
        {
            MySPI_W_MOSI(1);
        }else{
            MySPI_W_MOSI(0);
        }
        dat <<= 1;
        MySPI_W_SCK(1);
    }
    MySPI_Stop();
}

void SPIWriteCmd(uint8_t cmd)
{
    uint16_t temp = 0;
    temp = cmd;
    temp &= 0x00ff;
    SPIWrite(temp);
}

void SPIWriteData(uint8_t data)
{
    uint16_t temp = 0;
    temp = data;
    temp += 0x0100;
    temp &= 0x01ff;
    SPIWrite(temp);
}

void Delay_ms(unsigned int n)
{
	unsigned int  i,j;
	for(i=0;i<n;i++)
		for(j=0;j<123;j++);
}
#if USE_EXCEL 
void LCD_Init(void)
{
  SPIWrite(0x00FF); 
  SPIWrite(0x01FF); 
  SPIWrite(0x0198);
  SPIWrite(0x0106);
  SPIWrite(0x0104);
  SPIWrite(0x0101);	

  SPIWrite(0x0008);
  SPIWrite(0x0110);

  SPIWrite(0x0020);//5
  SPIWrite(0x0100);

  SPIWrite(0x0021);//5
  SPIWrite(0x0101);

  SPIWrite(0x0022);
  SPIWrite(0x0100);

  SPIWrite(0x0030);
  SPIWrite(0x0102);

  SPIWrite(0x0031);
  SPIWrite(0x0102);

  SPIWrite(0x0040);
  SPIWrite(0x0115);
  SPIWrite(0x0041);
  SPIWrite(0x0133);
  SPIWrite(0x0042);
  SPIWrite(0x0102);
  SPIWrite(0x0043);
  SPIWrite(0x0109);
  SPIWrite(0x0044);
  SPIWrite(0x0106);
  SPIWrite(0x0050);
  SPIWrite(0x0170);
  SPIWrite(0x0051);
  SPIWrite(0x0170);

  SPIWrite(0x0052);
  SPIWrite(0x0100);
  SPIWrite(0x0053);
  SPIWrite(0x012B);
  SPIWrite(0x0054);
  SPIWrite(0x0100);
  SPIWrite(0x0055);
  SPIWrite(0x0139);

  SPIWrite(0x0060);
  SPIWrite(0x0107);
  SPIWrite(0x0061);
  SPIWrite(0x0100);
  SPIWrite(0x0062);
  SPIWrite(0x0109);
  SPIWrite(0x0063);
  SPIWrite(0x0100);

  SPIWrite(0x00A0);
  SPIWrite(0x0108);
  SPIWrite(0x00A1);
  SPIWrite(0x0115);//5
  SPIWrite(0x00A2);
  SPIWrite(0x011D);//5
  SPIWrite(0x00A3);
  SPIWrite(0x010D);
  SPIWrite(0x00A4);
  SPIWrite(0x0106);
  SPIWrite(0x00A5);
  SPIWrite(0x010E);
  SPIWrite(0x00A6);
  SPIWrite(0x0108);
  SPIWrite(0x00A7);
  SPIWrite(0x0107);
  SPIWrite(0x00A8);
  SPIWrite(0x0106);
  SPIWrite(0x00A9);
  SPIWrite(0x011A);
  SPIWrite(0x00AA);
  SPIWrite(0x010B);
  SPIWrite(0x00AB);
  SPIWrite(0x0104);
  SPIWrite(0x00AC);
  SPIWrite(0x010A);
  SPIWrite(0x00AD);
  SPIWrite(0x0115);//5
  SPIWrite(0x00AE);
  SPIWrite(0x0111);//5
  SPIWrite(0x00AF);
  SPIWrite(0x0108);

  SPIWrite(0x00C0);
  SPIWrite(0x0108);
  SPIWrite(0x00C1);
  SPIWrite(0x0116);//15
  SPIWrite(0x00C2);
  SPIWrite(0x011E);//1D
  SPIWrite(0x00C3);
  SPIWrite(0x010D);
  SPIWrite(0x00C4);
  SPIWrite(0x0106);
  SPIWrite(0x00C5);
  SPIWrite(0x010F);
  SPIWrite(0x00C6);
  SPIWrite(0x0108);
  SPIWrite(0x00C7);
  SPIWrite(0x0107);
  SPIWrite(0x00C8);
  SPIWrite(0x0106);
  SPIWrite(0x00C9);
  SPIWrite(0x011A);
  SPIWrite(0x00CA);
  SPIWrite(0x010B);
  SPIWrite(0x00CB);
  SPIWrite(0x0104);
  SPIWrite(0x00CC);
  SPIWrite(0x010A);
  SPIWrite(0x00CD);
  SPIWrite(0x0115);//14
  SPIWrite(0x00CE);
  SPIWrite(0x0111);//10
  SPIWrite(0x00CF);
  SPIWrite(0x0108);
  Delay_ms(10);

  SPIWrite(0x00FF);
  SPIWrite(0x01FF);
  SPIWrite(0x0198);
  SPIWrite(0x0106);
  SPIWrite(0x0104);
  SPIWrite(0x0106);

  SPIWrite(0x0000);
  SPIWrite(0x0121);
  SPIWrite(0x0001);
  SPIWrite(0x010A);
  SPIWrite(0x0002);
  SPIWrite(0x0160);
  SPIWrite(0x0003);
  SPIWrite(0x010F);
  SPIWrite(0x0004);
  SPIWrite(0x0101);
  SPIWrite(0x0005);
  SPIWrite(0x0101);
  SPIWrite(0x0006);
  SPIWrite(0x0180);
  SPIWrite(0x0007);
  SPIWrite(0x0106);
  SPIWrite(0x0008);
  SPIWrite(0x0101);
  SPIWrite(0x0009);
  SPIWrite(0x0100);
  SPIWrite(0x000A);
  SPIWrite(0x0100);
  SPIWrite(0x000B);
  SPIWrite(0x0100);
  SPIWrite(0x000C);
  SPIWrite(0x0101);
  SPIWrite(0x000D);
  SPIWrite(0x0101);
  SPIWrite(0x000E);
  SPIWrite(0x0100);
  SPIWrite(0x000F);
  SPIWrite(0x0100);
  SPIWrite(0x0010);
  SPIWrite(0x01F7);
  SPIWrite(0x0011);
  SPIWrite(0x01F0);
  SPIWrite(0x0012);
  SPIWrite(0x0100);
  SPIWrite(0x0013);
  SPIWrite(0x0100);
  SPIWrite(0x0014);
  SPIWrite(0x0100);
  SPIWrite(0x0015);
  SPIWrite(0x01C0);
  SPIWrite(0x0016);
  SPIWrite(0x0108);
  SPIWrite(0x0017);
  SPIWrite(0x0101);
  SPIWrite(0x0018);
  SPIWrite(0x0101);
  SPIWrite(0x0019);
  SPIWrite(0x0100);
  SPIWrite(0x001A);
  SPIWrite(0x0100);
  SPIWrite(0x001B);
  SPIWrite(0x0100);
  SPIWrite(0x001C);
  SPIWrite(0x0100);
  SPIWrite(0x001D);
  SPIWrite(0x0100);
  SPIWrite(0x0020);
  SPIWrite(0x0101);
  SPIWrite(0x0021);
  SPIWrite(0x0123);
  SPIWrite(0x0022);
  SPIWrite(0x0145);
  SPIWrite(0x0023);
  SPIWrite(0x0167);
  SPIWrite(0x0024);
  SPIWrite(0x0101);
  SPIWrite(0x0025);
  SPIWrite(0x0123);
  SPIWrite(0x0026);
  SPIWrite(0x0145);
  SPIWrite(0x0027);
  SPIWrite(0x0167);
  SPIWrite(0x0030);
  SPIWrite(0x0101);
  SPIWrite(0x0031);
  SPIWrite(0x01DA);
  SPIWrite(0x0032);
  SPIWrite(0x01CB);
  SPIWrite(0x0033);
  SPIWrite(0x0122);
  SPIWrite(0x0034);
  SPIWrite(0x0122);
  SPIWrite(0x0035);
  SPIWrite(0x0111);
  SPIWrite(0x0036);
  SPIWrite(0x0100);
  SPIWrite(0x0037);
  SPIWrite(0x01AD);
  SPIWrite(0x0038);
  SPIWrite(0x01BC);
  SPIWrite(0x0039);
  SPIWrite(0x0176);
  SPIWrite(0x003A);
  SPIWrite(0x0167);
  SPIWrite(0x003B);
  SPIWrite(0x0188);
  SPIWrite(0x003C);
  SPIWrite(0x0122);
  SPIWrite(0x003D);
  SPIWrite(0x0122);
  SPIWrite(0x003E);
  SPIWrite(0x0122);
  SPIWrite(0x003F);
  SPIWrite(0x0122);
  SPIWrite(0x0040);
  SPIWrite(0x0122);
  SPIWrite(0x0052);
  SPIWrite(0x0112);
  SPIWrite(0x0053);
  SPIWrite(0x0112);

  SPIWrite(0x00FF);
  SPIWrite(0x01FF);
  SPIWrite(0x0198);
  SPIWrite(0x0106);
  SPIWrite(0x0104);
  SPIWrite(0x0107);

  SPIWrite(0x0018);
  SPIWrite(0x011D);

  SPIWrite(0x0017);
  SPIWrite(0x0132);

  SPIWrite(0x0002);
  SPIWrite(0x0177);

  SPIWrite(0x00E1);//无
  SPIWrite(0x0179);//无

  SPIWrite(0x0026);//无
  SPIWrite(0x01B2);//无

  SPIWrite(0x00FF);
  SPIWrite(0x01FF);
  SPIWrite(0x0198);
  SPIWrite(0x0106);
  SPIWrite(0x0104);
  SPIWrite(0x0100);

  SPIWrite(0x003A);
  SPIWrite(0x0170);

  SPIWrite(0x0036);
  SPIWrite(0x0100);

  SPIWrite(0x0011);	
    Delay_ms(120);     	 

  SPIWrite(0x0029);
    Delay_ms(20); 
  
}
#else
void LCD_Init(void)
{
    SPIWriteCmd(0xFF);
    SPIWriteData(0xFF);
    SPIWriteData(0x98);
    SPIWriteData(0x06);
    SPIWriteData(0x04);
    SPIWriteData(0x01); //go to page 1
    
    SPIWriteCmd(0x08);
    SPIWriteData(0x10); //interface mode
#if USE_DIFFERENCE
    

    SPIWriteCmd(0x21);//5
    SPIWriteData(0x01);
#endif
    
    SPIWriteCmd(0x20);//5
    SPIWriteData(0x00);
    
    SPIWriteCmd(0x22);
    SPIWriteData(0x00); //Source &gate output direction
    
    SPIWriteCmd(0x30);
    SPIWriteData(0x02); //Resolution Control
    
    SPIWriteCmd(0x31);
    SPIWriteData(0x00); //Display Inversion Control //check
    
    SPIWriteCmd(0x40);
    SPIWriteData(0x15); 
    
    SPIWriteCmd(0x41);
    SPIWriteData(0x33); 
    
    SPIWriteCmd(0x42);
    SPIWriteData(0x02); 
    
    SPIWriteCmd(0x43);
    SPIWriteData(0x09); 
    
    SPIWriteCmd(0x44);
    SPIWriteData(0x06); 
    
    SPIWriteCmd(0x45);
    SPIWriteData(0xD6); 
    
    SPIWriteCmd(0x50);
    SPIWriteData(0x70);
    
    SPIWriteCmd(0x51);
    SPIWriteData(0x70); //Power Control
    
    SPIWriteCmd(0x52);
    SPIWriteData(0x00); 
    
    SPIWriteCmd(0x53);
    SPIWriteData(0x2B); 
    
    SPIWriteCmd(0x54);
    SPIWriteData(0x00);
    
    SPIWriteCmd(0x55);
    SPIWriteData(0x39); //Vcom Setting
    
    SPIWriteCmd(0x60);
    SPIWriteData(0x07); 
    
    SPIWriteCmd(0x61);
    SPIWriteData(0x00); 
    
    SPIWriteCmd(0x62);
    SPIWriteData(0x09);
    
    SPIWriteCmd(0x63);
    SPIWriteData(0x00); //Timing //check
    
    SPIWriteCmd(0xA0);
    SPIWriteData(0x08); 

    SPIWriteCmd(0xA1);
    SPIWriteData(0x14); 
    
    SPIWriteCmd(0xA2);
    SPIWriteData(0x1C);  
    
    SPIWriteCmd(0xA3);
    SPIWriteData(0x0D); 
    
    SPIWriteCmd(0xA4);
    SPIWriteData(0x06); 
    
    SPIWriteCmd(0xA5);
    SPIWriteData(0x0E); 
    
    SPIWriteCmd(0xA6);
    SPIWriteData(0x08); 
    
    SPIWriteCmd(0xA7);
    SPIWriteData(0x07); 
    
    SPIWriteCmd(0xA8);
    SPIWriteData(0x06); 
    
    SPIWriteCmd(0xA9);
    SPIWriteData(0x1A); 
    
    SPIWriteCmd(0xAA);
    SPIWriteData(0x0B); 
    
    SPIWriteCmd(0xAB);
    SPIWriteData(0x04); 
    
    SPIWriteCmd(0xAC);
    SPIWriteData(0x0A); 
    
    SPIWriteCmd(0xAD);
    SPIWriteData(0x14); 
    
    SPIWriteCmd(0xAE);
    SPIWriteData(0x10); 
    
    SPIWriteCmd(0xAF);
    SPIWriteData(0x08); //Power Gamma Settipng //check
    
    SPIWriteCmd(0xC0);
    SPIWriteData(0x08); 
    
    SPIWriteCmd(0xC1);
    SPIWriteData(0x15); 
    
    SPIWriteCmd(0xC2);
    SPIWriteData(0x1D); 
    
    SPIWriteCmd(0xC3);
    SPIWriteData(0x0D); 
    
    SPIWriteCmd(0xC4);
    SPIWriteData(0x06); 
    
    SPIWriteCmd(0xC5);
    SPIWriteData(0x0F); 
    
    SPIWriteCmd(0xC6);
    SPIWriteData(0x08); 
    
    SPIWriteCmd(0xC7);
    SPIWriteData(0x07); 
    
    SPIWriteCmd(0xC8);
    SPIWriteData(0x06); 
    
    SPIWriteCmd(0xC9);
    SPIWriteData(0x1A); 
    
    SPIWriteCmd(0xCA);
    SPIWriteData(0x0B); 
    
    SPIWriteCmd(0xCB);
    SPIWriteData(0x04); 
    
    SPIWriteCmd(0xCC);
    SPIWriteData(0x0A); 
    
    SPIWriteCmd(0xCD);
    SPIWriteData(0x14); 
    
    SPIWriteCmd(0xCE);
    SPIWriteData(0x10); 
    
    SPIWriteCmd(0xCF);
    SPIWriteData(0x08); //Negitive Gamma setting //CHECK
    
    Delay_ms(100); //delay 10ms
    
    SPIWriteCmd(0xFF);
    SPIWriteData(0xFF);
    SPIWriteData(0x98);
    SPIWriteData(0x06);
    SPIWriteData(0x04);
    SPIWriteData(0x06); //go to page 6
    
    SPIWriteCmd(0x00); SPIWriteData(0x21); 
    
    SPIWriteCmd(0x01); SPIWriteData(0x0A); 

    SPIWriteCmd(0x02); SPIWriteData(0x60); 
    
    SPIWriteCmd(0x03); SPIWriteData(0x0F); 
    
    SPIWriteCmd(0x04); SPIWriteData(0x01); 
    
    SPIWriteCmd(0x05); SPIWriteData(0x01); 
    
    SPIWriteCmd(0x06); SPIWriteData(0x80); 
    
    SPIWriteCmd(0x07); SPIWriteData(0x06); 
    
    SPIWriteCmd(0x08); SPIWriteData(0x01); 
    
    SPIWriteCmd(0x09); SPIWriteData(0x00); 
    
    SPIWriteCmd(0x0A); SPIWriteData(0x00); 
    
    SPIWriteCmd(0x0B); SPIWriteData(0x00); 
    
    SPIWriteCmd(0x0C); SPIWriteData(0x01); 
    
    SPIWriteCmd(0x0D); SPIWriteData(0x01); 
    
    SPIWriteCmd(0x0E); SPIWriteData(0x00); 
    
    SPIWriteCmd(0x0F); SPIWriteData(0x00); //0x0F check
    
    SPIWriteCmd(0x10); SPIWriteData(0xF7); 
                  
    SPIWriteCmd(0x11); SPIWriteData(0xF0); 
                  
    SPIWriteCmd(0x12); SPIWriteData(0x00); 
                  
    SPIWriteCmd(0x13); SPIWriteData(0x00); 
                  
    SPIWriteCmd(0x14); SPIWriteData(0x00); 
                  
    SPIWriteCmd(0x15); SPIWriteData(0xC0); 
                  
    SPIWriteCmd(0x16); SPIWriteData(0x08); 
                  
    SPIWriteCmd(0x17); SPIWriteData(0x01); 
                  
    SPIWriteCmd(0x18); SPIWriteData(0x01); 
                  
    SPIWriteCmd(0x19); SPIWriteData(0x00); 
                  
    SPIWriteCmd(0x1A); SPIWriteData(0x00); 
                  
    SPIWriteCmd(0x1B); SPIWriteData(0x00); 
                  
    SPIWriteCmd(0x1C); SPIWriteData(0x00); 
                  
    SPIWriteCmd(0x1D); SPIWriteData(0x00);  //0x1D check
                  
    SPIWriteCmd(0x20); SPIWriteData(0x00); 
                  
    SPIWriteCmd(0x21); SPIWriteData(0x23); 
                  
    SPIWriteCmd(0x22); SPIWriteData(0x45); 
                  
    SPIWriteCmd(0x23); SPIWriteData(0x67); 
                  
    SPIWriteCmd(0x24); SPIWriteData(0x01); 
                  
    SPIWriteCmd(0x25); SPIWriteData(0x23); 
                  
    SPIWriteCmd(0x26); SPIWriteData(0x45); 
                  
    SPIWriteCmd(0x27); SPIWriteData(0x67);  //0x27 check
                  
    SPIWriteCmd(0x30); SPIWriteData(0x03); 
                  
    SPIWriteCmd(0x31); SPIWriteData(0xDA); 
                  
    SPIWriteCmd(0x32); SPIWriteData(0xCB); 
                  
    SPIWriteCmd(0x33); SPIWriteData(0x22); 
                  
    SPIWriteCmd(0x34); SPIWriteData(0x22); 
                  
    SPIWriteCmd(0x35); SPIWriteData(0x11); 
                  
    SPIWriteCmd(0x36); SPIWriteData(0x00); 
    
    SPIWriteCmd(0x37); SPIWriteData(0xAD); 
                  
    SPIWriteCmd(0x38); SPIWriteData(0xBC); 
                  
    SPIWriteCmd(0x39); SPIWriteData(0x76); 
                  
    SPIWriteCmd(0x3A); SPIWriteData(0x67); 
                  
    SPIWriteCmd(0x3B); SPIWriteData(0x88); 
                  
    SPIWriteCmd(0x3C); SPIWriteData(0x22); 
                  
    SPIWriteCmd(0x3D); SPIWriteData(0x22); 
                  
    SPIWriteCmd(0x3E); SPIWriteData(0x22);

    SPIWriteCmd(0x3F); SPIWriteData(0x22);
    
    SPIWriteCmd(0x40); SPIWriteData(0x22);
    
    SPIWriteCmd(0x52); SPIWriteData(0x12);

    SPIWriteCmd(0x53); SPIWriteData(0x12); //GIP Setting CHECK
    
    SPIWriteCmd(0xFF);
    SPIWriteData(0xFF);
    SPIWriteData(0x98);
    SPIWriteData(0x06);
    SPIWriteData(0x04);
    SPIWriteData(0x07); //go to page 7
    
    SPIWriteCmd(0x18); SPIWriteData(0x1D); //VrEG1/2 Out Enable
    
    SPIWriteCmd(0x17); SPIWriteData(0x32); //VGL_REG EN
    
    SPIWriteCmd(0x02); SPIWriteData(0x77); //Power Bais Control
    
    SPIWriteCmd(0xFF);
    SPIWriteData(0xFF);
    SPIWriteData(0x98);
    SPIWriteData(0x06);
    SPIWriteData(0x04);
    SPIWriteData(0x00); //go to page 0
    
    SPIWriteCmd(0x3A); SPIWriteData(0x70); //Interface Pixel Format
    
    SPIWriteCmd(0x36); SPIWriteData(0x00);
    
    
    Delay_ms(10); //delay 10ms
    
    SPIWriteCmd(0x11); //SPIWriteData(0x00);
    
    Delay_ms(1200);
    
    SPIWriteCmd(0x29);
    
    Delay_ms(2000);
//0x27 check
    //Negitive Gamma setting //CHECK
}
#endif